﻿//  Copyright (c) 2004-2009 Sergey Lyubka
//
//  Permission is hereby granted, free of charge, to any person obtaining a copy
//  of this software and associated documentation files (the "Software"), to deal
//  in the Software without restriction, including without limitation the rights
//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//  copies of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//
//  The above copyright notice and this permission notice shall be included in
//  all copies or substantial portions of the Software.
//
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//  THE SOFTWARE.
//
//  $Id$

using System;
using System.Runtime.InteropServices;
using System.Net;
using System.Threading;


[StructLayout(LayoutKind.Sequential)]
public struct MongooseHeader
{
    public IntPtr name;		// Using IntPtr here because if we use strings here,
    public IntPtr value;		// it won't be properly marshalled.
};

// This is "struct mg_request_info" from mongoose.h header file
[StructLayout(LayoutKind.Sequential)]
public struct MongooseRequestInfo
{
    public string request_method;
    public string UriPath;
    public string http_version;
    public string QueryString;
    public IntPtr post_data;
    public string remote_user;
    public uint remote_ip; //int to match the 32bit declaration in c
    public int remote_port;
    public int post_data_len;
    public int status_code;
    public int num_headers;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
    public MongooseHeader[] http_headers;
};

// This is a delegate for mg_callback_t from mongoose.h header file
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void MongooseCallback2(IntPtr conn, ref MongooseRequestInfo ri, IntPtr user_data);

// This is a delegate to be used by the application
public delegate void MongooseCallback(MongooseConnection conn, MongooseRequestInfo ri);

public class Mongoose
{
    public string version;
    private IntPtr ctx;
    //These two events are here to store a ref to the callbacks while they are over in unmanaged code. 
    private event MongooseCallback2 delegates2;
    private event MongooseCallback delegates1;

    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr mg_start();
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern void mg_stop(IntPtr ctx);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern string mg_version();
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern int mg_set_option(IntPtr ctx, string name, string value);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern string mg_get_option(IntPtr ctx, string name);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern void mg_set_uri_callback(IntPtr ctx, string uri_regex, MulticastDelegate func, IntPtr data);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern void mg_set_log_callback(IntPtr ctx, MulticastDelegate func);

    public Mongoose()
    {
        ctx = mg_start();
        version = mg_version();
    }

    ~Mongoose()
    {
        mg_stop(this.ctx);
        this.ctx = IntPtr.Zero;
    }

    public int set_option(string option_name, string option_value)
    {
        return mg_set_option(this.ctx, option_name, option_value);
    }

    public string get_option(string option_name)
    {
        return mg_get_option(this.ctx, option_name);
    }

    public void set_uri_callback(string uri_regex, MongooseCallback func)
    {
        // Build a closure around user function. Initialize connection object there which wraps
        // mg_write() and other useful methods, and then call user specified handler.
        MongooseCallback2 callback = delegate(IntPtr conn, ref MongooseRequestInfo ri, IntPtr user_data)
        {
            MongooseConnection connection = new MongooseConnection(conn, this);
            func(connection, ri);
        };
        // store a reference to the callback so it won't be GC'ed while its over in unmanged code
        delegates2 += callback;
        mg_set_uri_callback(this.ctx, uri_regex, callback, IntPtr.Zero);
    }

    public void set_log_callback(MongooseCallback func)
    {
        delegates1 += func;
        mg_set_log_callback(this.ctx, func);
    }

}

public class MongooseConnection
{
    public Mongoose mongoose;
    private IntPtr conn;

    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern string mg_get_header(IntPtr ctx, string name);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern string mg_get_var(IntPtr ctx, string name);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    private static extern void mg_free(IntPtr ptr);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    public static extern int mg_write(IntPtr conn, string data, int length);
    [DllImport("_mongoose", CallingConvention = CallingConvention.Cdecl)]
    public static extern int mg_write(IntPtr conn, byte[] data, int length);

    public MongooseConnection(IntPtr conn_, Mongoose mongoose_)
    {
        mongoose = mongoose_;
        conn = conn_;
    }

    public string get_header(string header_name)
    {
        return mg_get_header(this.conn, header_name);
    }

    public string get_var(string header_name)
    {
        string s = mg_get_var(this.conn, header_name);
        string copy = "" + s;
        mg_free(Marshal.StringToHGlobalAnsi(s));
        return copy;
    }

    public int write(string data)
    {
        return mg_write(this.conn, data, data.Length);
    }

    public void Send(HttpStatusCode StatusCode, byte[] Body)
    {
        var header = string.Format("HTTP/1.1 {0} {1}\r\nDate: {2}\r\nServer: Popro Tracker\r\nContent-Length: {3}\r\nConnection: close\r\nContent-Type: {4}\r\n\r\n",
            (int)StatusCode, StatusCode.ToString(), DateTime.UtcNow.ToString("r"), Body.Length, StatusCode == HttpStatusCode.OK ? "text/BEncoding; charset=binary" : "text/plain");
        mg_write(this.conn, header, header.Length);
        mg_write(this.conn, Body, Body.Length);
    }

    public void Send(byte[] Body)
    {
        Send(HttpStatusCode.OK, Body);
    }

}